-- Network Working Group                                            D. Levi
-- Request for Comments: 2591                               Nortel Networks
-- Category: Standards Track                               J. Schoenwaelder
--                                                          TU Braunschweig
--                                                                 May 1999
-- 
-- 
--                    Definitions of Managed Objects for
--                     Scheduling Management Operations


    DISMAN-SCHEDULE-MIB DEFINITIONS ::= BEGIN

    IMPORTS
        MODULE-IDENTITY, OBJECT-TYPE, NOTIFICATION-TYPE,
        Integer32, Unsigned32, Counter32, mib-2
            FROM SNMPv2-SMI

        TEXTUAL-CONVENTION,
        DateAndTime, RowStatus, StorageType, VariablePointer
            FROM SNMPv2-TC

        MODULE-COMPLIANCE, OBJECT-GROUP, NOTIFICATION-GROUP
            FROM SNMPv2-CONF

        SnmpAdminString
            FROM SNMP-FRAMEWORK-MIB;

    schedMIB MODULE-IDENTITY
        LAST-UPDATED "9811171800Z"
        ORGANIZATION "IETF Distributed Management Working Group"
        CONTACT-INFO
            "David B. Levi
             Nortel Networks
             4401 Great America Parkway
             Santa Clara, CA 95052-8185
             U.S.A.
             Tel: +1 423 686 0432
             E-mail: dlevi@nortelnetworks.com

             Juergen Schoenwaelder
             TU Braunschweig
             Bueltenweg 74/75
             38106 Braunschweig
             Germany
             Tel: +49 531 391-3283
             E-mail: schoenw@ibr.cs.tu-bs.de"
        DESCRIPTION
            "This MIB module defines a MIB which provides mechanisms
             to schedule SNMP set operations periodically or at
             specific points in time."
        ::= { mib-2 63 }

    --
    -- The various groups defined within this MIB definition:
    --

    schedObjects       OBJECT IDENTIFIER ::= { schedMIB 1 }
    schedNotifications OBJECT IDENTIFIER ::= { schedMIB 2 }
    schedConformance   OBJECT IDENTIFIER ::= { schedMIB 3 }

    --
    -- Textual Conventions:
    --

    SnmpPduErrorStatus ::= TEXTUAL-CONVENTION
        STATUS       current
        DESCRIPTION
            "This TC enumerates the SNMPv1 and SNMPv2 PDU error status
             codes as defined in RFC 1157 and RFC 1905. It also adds a
             pseudo error status code `noResponse' which indicates a
             timeout condition."
        SYNTAX      INTEGER {
                        noResponse(-1),
                        noError(0),
                        tooBig(1),
                        noSuchName(2),
                        badValue(3),
                        readOnly(4),
                        genErr(5),
                        noAccess(6),
                        wrongType(7),
                        wrongLength(8),
                        wrongEncoding(9),
                        wrongValue(10),
                        noCreation(11),
                        inconsistentValue(12),
                        resourceUnavailable(13),
                        commitFailed(14),
                        undoFailed(15),
                        authorizationError(16),
                        notWritable(17),
                        inconsistentName(18)
                    }

    --
    -- Some scalars which provide information about the local time
    -- zone.
    --

    schedLocalTime OBJECT-TYPE
        SYNTAX      DateAndTime (SIZE (11))
        MAX-ACCESS  read-only
        STATUS      current
        DESCRIPTION
            "The local time used by the scheduler. Schedules which
             refer to calendar time will use the local time indicated
             by this object. An implementation MUST return all 11 bytes
             of the DateAndTime textual-convention so that a manager
             may retrieve the offset from GMT time."
        ::= { schedObjects 1 }

    --
    -- The schedule table which controls the scheduler.
    --

    schedTable OBJECT-TYPE
        SYNTAX      SEQUENCE OF SchedEntry
        MAX-ACCESS  not-accessible
        STATUS      current
        DESCRIPTION
            "This table defines scheduled actions triggered by
             SNMP set operations."
        ::= { schedObjects 2 }

    schedEntry OBJECT-TYPE
        SYNTAX      SchedEntry
        MAX-ACCESS  not-accessible
        STATUS      current
        DESCRIPTION
            "An entry describing a particular scheduled action."
        INDEX { schedOwner, schedName }
        ::= { schedTable 1 }

    SchedEntry ::= SEQUENCE {
        schedOwner          SnmpAdminString,
        schedName           SnmpAdminString,
        schedDescr          SnmpAdminString,
        schedInterval       Unsigned32,
        schedWeekDay        BITS,
        schedMonth          BITS,
        schedDay            BITS,
        schedHour           BITS,
        schedMinute         BITS,
        schedContextName    SnmpAdminString,
        schedVariable       VariablePointer,
        schedValue          Integer32,
        schedType           INTEGER,
        schedAdminStatus    INTEGER,
        schedOperStatus     INTEGER,
        schedFailures       Counter32,
        schedLastFailure    SnmpPduErrorStatus,
        schedLastFailed     DateAndTime,
        schedStorageType    StorageType,
        schedRowStatus      RowStatus
    }

    schedOwner OBJECT-TYPE
        SYNTAX      SnmpAdminString (SIZE(0..32))
        MAX-ACCESS  not-accessible
        STATUS      current
        DESCRIPTION
            "The owner of this scheduling entry. The exact semantics of
             this string are subject to the security policy defined by
             the security administrator."
        ::= { schedEntry 1 }

    schedName OBJECT-TYPE
        SYNTAX      SnmpAdminString (SIZE(1..32))
        MAX-ACCESS  not-accessible
        STATUS      current
        DESCRIPTION
            "The locally-unique, administratively assigned name for this
             scheduling entry. This object allows a schedOwner to have
             multiple entries in the schedTable."
        ::= { schedEntry 2 }

    schedDescr OBJECT-TYPE
        SYNTAX      SnmpAdminString
        MAX-ACCESS  read-create
        STATUS      current
        DESCRIPTION
            "The human readable description of the purpose of this
             scheduling entry."
        DEFVAL { ''H }
        ::= { schedEntry 3 }

    schedInterval OBJECT-TYPE
        SYNTAX      Unsigned32
        UNITS       "seconds"
        MAX-ACCESS  read-create
        STATUS      current
        DESCRIPTION
            "The number of seconds between two action invocations of
             a periodic scheduler. Implementations must guarantee
             that action invocations will not occur before at least
             schedInterval seconds have passed.

             The scheduler must ignore all periodic schedules that
             have a schedInterval value of 0. A periodic schedule
             with a scheduling interval of 0 seconds will therefore
             never invoke an action.

             Implementations may be forced to delay invocations in the
             face of local constraints. A scheduled management function
             should therefore not rely on the accuracy provided by the
             scheduler implementation."
        DEFVAL { 0 }
        ::= { schedEntry 4 }

    schedWeekDay OBJECT-TYPE
        SYNTAX      BITS {
                        sunday(0),
                        monday(1),
                        tuesday(2),
                        wednesday(3),
                        thursday(4),
                        friday(5),
                        saturday(6)
                    }
        MAX-ACCESS  read-create
        STATUS      current
        DESCRIPTION
            "The set of weekdays on which the scheduled action should
             take place. Setting multiple bits will include several
             weekdays in the set of possible weekdays for this schedule.
             Setting all bits will cause the scheduler to ignore the
             weekday."
        DEFVAL { {} }
        ::= { schedEntry 5 }

    schedMonth OBJECT-TYPE
        SYNTAX      BITS {
                        january(0),
                        february(1),
                        march(2),
                        april(3),
                        may(4),
                        june(5),
                        july(6),
                        august(7),
                        september(8),
                        october(9),
                        november(10),
                        december(11)
                    }
        MAX-ACCESS  read-create
        STATUS      current
        DESCRIPTION
            "The set of months during which the scheduled action should
             take place. Setting multiple bits will include several
             months in the set of possible months for this schedule.
             Setting all bits will cause the scheduler to ignore the
             month."
        DEFVAL { {} }
        ::= { schedEntry 6 }

    schedDay OBJECT-TYPE
        SYNTAX      BITS {
                        d1(0),   d2(1),   d3(2),   d4(3),   d5(4),
                        d6(5),   d7(6),   d8(7),   d9(8),   d10(9),
                        d11(10), d12(11), d13(12), d14(13), d15(14),
                        d16(15), d17(16), d18(17), d19(18), d20(19),
                        d21(20), d22(21), d23(22), d24(23), d25(24),
                        d26(25), d27(26), d28(27), d29(28), d30(29),
                        d31(30),
                        r1(31),  r2(32),  r3(33),  r4(34),  r5(35),
                        r6(36),  r7(37),  r8(38),  r9(39),  r10(40),
                        r11(41), r12(42), r13(43), r14(44), r15(45),
                        r16(46), r17(47), r18(48), r19(49), r20(50),
                        r21(51), r22(52), r23(53), r24(54), r25(55),
                        r26(56), r27(57), r28(58), r29(59), r30(60),
                        r31(61)
                    }
        MAX-ACCESS  read-create
        STATUS      current
        DESCRIPTION
            "The set of days in a month on which a scheduled action
             should take place. There are two sets of bits one can
             use to define the day within a month:

             Enumerations starting with the letter 'd' indicate a
             day in a month relative to the first day of a month.
             The first day of the month can therefore be specified
             by setting the bit d1(0) and d31(30) means the last
             day of a month with 31 days.

             Enumerations starting with the letter 'r' indicate a
             day in a month in reverse order, relative to the last
             day of a month. The last day in the month can therefore
             be specified by setting the bit r1(31) and r31(61) means
             the first day of a month with 31 days.

             Setting multiple bits will include several days in the set
             of possible days for this schedule. Setting all bits will
             cause the scheduler to ignore the day within a month.
             Setting all bits starting with the letter 'd' or the
             letter 'r' will also cause the scheduler to ignore the
             day within a month."
        DEFVAL { {} }
        ::= { schedEntry 7 }

    schedHour OBJECT-TYPE
        SYNTAX      BITS {
                        h0(0),   h1(1),   h2(2),   h3(3),   h4(4),
                        h5(5),   h6(6),   h7(7),   h8(8),   h9(9),
                        h10(10), h11(11), h12(12), h13(13), h14(14),
                        h15(15), h16(16), h17(17), h18(18), h19(19),
                        h20(20), h21(21), h22(22), h23(23)
                    }
        MAX-ACCESS  read-create
        STATUS      current
        DESCRIPTION
            "The set of hours within a day during which the scheduled
             action should take place."
        DEFVAL { {} }
        ::= { schedEntry 8 }

    schedMinute OBJECT-TYPE
        SYNTAX      BITS {
                        m0(0),   m1(1),   m2(2),   m3(3),   m4(4),
                        m5(5),   m6(6),   m7(7),   m8(8),   m9(9),
                        m10(10), m11(11), m12(12), m13(13), m14(14),
                        m15(15), m16(16), m17(17), m18(18), m19(19),
                        m20(20), m21(21), m22(22), m23(23), m24(24),
                        m25(25), m26(26), m27(27), m28(28), m29(29),
                        m30(30), m31(31), m32(32), m33(33), m34(34),
                        m35(35), m36(36), m37(37), m38(38), m39(39),
                        m40(40), m41(41), m42(42), m43(43), m44(44),
                        m45(45), m46(46), m47(47), m48(48), m49(49),
                        m50(50), m51(51), m52(52), m53(53), m54(54),
                        m55(55), m56(56), m57(57), m58(58), m59(59)
                    }
        MAX-ACCESS  read-create
        STATUS      current
        DESCRIPTION
            "The set of minutes within an hour when the scheduled action
             should take place."
        DEFVAL { {} }
        ::= { schedEntry 9 }

    schedContextName OBJECT-TYPE
        SYNTAX      SnmpAdminString (SIZE(0..32))
        MAX-ACCESS  read-create
        STATUS      current
        DESCRIPTION
            "The context which contains the local MIB variable pointed
             to by schedVariable."
        ::= { schedEntry 10 }

    schedVariable OBJECT-TYPE
        SYNTAX      VariablePointer
        MAX-ACCESS  read-create
        STATUS      current
        DESCRIPTION
            "An object identifier pointing to a local MIB variable
             which resolves to an ASN.1 primitive type of INTEGER."
        ::= { schedEntry 11 }

    schedValue OBJECT-TYPE
        SYNTAX      Integer32
        MAX-ACCESS  read-create
        STATUS      current
        DESCRIPTION
            "The value which is written to the MIB object pointed to by
             schedVariable when the scheduler invokes an action. The
             implementation shall enforce the use of access control
             rules when performing the set operation on schedVariable.
             This is accomplished by calling the isAccessAllowed abstract
             service interface as defined in RFC 2271."
        ::= { schedEntry 12 }

    schedType OBJECT-TYPE
        SYNTAX      INTEGER {
                        periodic(1),
                        calendar(2),
                        oneshot(3)
                    }
        MAX-ACCESS  read-create
        STATUS      current
        DESCRIPTION
            "The type of this schedule. The value periodic(1) indicates
             that this entry specifies a periodic schedule. A periodic
             schedule is defined by the value of schedInterval. The
             values of schedWeekDay, schedMonth, schedDay, schedHour
             and schedMinute are ignored.

             The value calendar(2) indicates that this entry describes a
             calendar schedule. A calendar schedule is defined by the
             values of schedWeekDay, schedMonth, schedDay, schedHour and
             schedMinute. The value of schedInterval is ignored. A
             calendar schedule will trigger on all local times that
             satisfy the bits set in schedWeekDay, schedMonth, schedDay,
             schedHour and schedMinute.

             The value oneshot(3) indicates that this entry describes a
             one-shot schedule. A one-shot schedule is similar to a
             calendar schedule with the additional feature that it
             disables itself by changing in the `finished'
             schedOperStatus once the schedule triggers an action.

             Changing a schedule's type is equivalent to deleting the
             old-type schedule and creating a new-type one."
        DEFVAL { periodic }
        ::= { schedEntry 13 }

    schedAdminStatus OBJECT-TYPE
        SYNTAX      INTEGER {
                        enabled(1),
                        disabled(2)
                    }
        MAX-ACCESS  read-create
        STATUS      current
        DESCRIPTION
            "The desired state of the schedule."
        DEFVAL { disabled }
        ::= { schedEntry 14 }

    schedOperStatus OBJECT-TYPE
        SYNTAX      INTEGER {
                        enabled(1),
                        disabled(2),
                        finished(3)
                    }
        MAX-ACCESS  read-only
        STATUS      current
        DESCRIPTION
            "The current operational state of this schedule. The state
             enabled(1) indicates this entry is active and that the
             scheduler will invoke actions at appropriate times. The
             disabled(2) state indicates that this entry is currently
             inactive and ignored by the scheduler. The finished(3)
             state indicates that the schedule has ended. Schedules
             in the finished(3) state are ignored by the scheduler.
             A one-shot schedule enters the finished(3) state when it
             deactivates itself."
        ::= { schedEntry 15 }

    schedFailures OBJECT-TYPE
        SYNTAX      Counter32
        MAX-ACCESS  read-only
        STATUS      current
        DESCRIPTION
            "This variable counts the number of failures while invoking
             the scheduled action."
        ::= { schedEntry 16 }

    schedLastFailure OBJECT-TYPE
        SYNTAX      SnmpPduErrorStatus
        MAX-ACCESS  read-only
        STATUS      current
        DESCRIPTION
            "The most recent error that occured during the invocation of
             a scheduled action. The value noError(0) is returned
             if no errors have occurred yet."
        DEFVAL { noError }
        ::= { schedEntry 17 }

    schedLastFailed OBJECT-TYPE
        SYNTAX      DateAndTime
        MAX-ACCESS  read-only
        STATUS      current
        DESCRIPTION
            "The date and time when the most recent failure occured. The
             value '0000000000000000'H is returned if no failure occured
             since the last re-initialization of the scheduler."
        DEFVAL { '0000000000000000'H }
        ::= { schedEntry 18 }

    schedStorageType OBJECT-TYPE
        SYNTAX      StorageType
        MAX-ACCESS  read-create
        STATUS      current
        DESCRIPTION
            "This object defines whether this scheduled action is kept
             in volatile storage and lost upon reboot or if this row is
             backed up by non-volatile or permanent storage.
             Conceptual rows having the value `permanent' must allow
             write access to the columnar objects schedDescr,
             schedInterval, schedContextName, schedVariable, schedValue,
             and schedAdminStatus. If an implementation supports the
             schedCalendarGroup, write access must be also allowed to
             the columnar objects schedWeekDay, schedMonth, schedDay,
             schedHour, schedMinute."
        DEFVAL { volatile }
        ::= { schedEntry 19 }

    schedRowStatus OBJECT-TYPE
        SYNTAX      RowStatus
        MAX-ACCESS  read-create
        STATUS      current
        DESCRIPTION
            "The status of this scheduled action. A control that allows
             entries to be added and removed from this table.

             The miminum number of objects that need to be set during
             row creation before a row can be set to `active' are
             schedContextName, schedVariable and schedValue."
        ::= { schedEntry 20 }

    --
    -- Notifications that are emitted to indicate failures. The
    -- definition of schedTraps makes notification registrations
    -- reversible (see STD 58, RFC 2578).
    --

    schedTraps OBJECT IDENTIFIER ::= { schedNotifications 0 }

    schedActionFailure NOTIFICATION-TYPE
        OBJECTS     { schedLastFailure, schedLastFailed }
        STATUS      current
        DESCRIPTION
            "This notification is generated whenever the invocation of a
             scheduled action fails."
        ::= { schedTraps 1 }

    -- conformance information

    schedCompliances OBJECT IDENTIFIER ::= { schedConformance 1 }
    schedGroups      OBJECT IDENTIFIER ::= { schedConformance 2 }

    -- compliance statements

    schedCompliance MODULE-COMPLIANCE
        STATUS      current
        DESCRIPTION
            "The compliance statement for SNMP entities which implement
             the scheduling MIB."
        MODULE      -- this module
        MANDATORY-GROUPS {
               schedGroup, schedNotificationsGroup
        }
        GROUP  schedCalendarGroup
        DESCRIPTION
            "The schedCalendarGroup is mandatory only for those
             implementations that support calendar based schedules."
        OBJECT schedType
        DESCRIPTION
            "The values calendar(2) or oneshot(3) are not valid for
             implementations that do not implement the
             schedCalendarGroup. Such an implementation must return
             inconsistentValue error responses for attempts to set
             schedAdminStatus to calendar(2) or oneshot(3)."
        ::= { schedCompliances 1 }

    schedGroup OBJECT-GROUP
        OBJECTS {
            schedDescr,
            schedInterval,
            schedContextName,
            schedVariable,
            schedValue,
            schedType,
            schedAdminStatus,
            schedOperStatus,
            schedFailures,
            schedLastFailure,
            schedLastFailed,
            schedStorageType,
            schedRowStatus
        }
        STATUS      current
        DESCRIPTION
            "A collection of objects providing scheduling capabilities."
        ::= { schedGroups 1 }

    schedCalendarGroup OBJECT-GROUP
        OBJECTS {
            schedLocalTime,
            schedWeekDay,
            schedMonth,
            schedDay,
            schedHour,
            schedMinute
        }
        STATUS      current
        DESCRIPTION
            "A collection of objects providing calendar based schedules."
        ::= { schedGroups 2 }

    schedNotificationsGroup NOTIFICATION-GROUP
        NOTIFICATIONS {
            schedActionFailure
        }
        STATUS      current
        DESCRIPTION
            "The notifications emitted by the scheduler."
        ::= { schedGroups 3 }

    END